{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 106,
   "metadata": {},
   "outputs": [],
   "source": [
    "#2022/02/30\n",
    "#张赛赛\n",
    "#pv_model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 330,
   "metadata": {},
   "outputs": [],
   "source": [
    "import warnings\n",
    "warnings.filterwarnings('ignore')\n",
    "\n",
    "import os\n",
    "import pandas as pd\n",
    "import numpy as np\n",
    "from tensorflow.keras.models import Sequential,load_model\n",
    "from tensorflow.keras.layers import LSTM,Dense,Activation,Dropout,Flatten,Conv1D,Conv2D,MaxPooling2D,Reshape,RepeatVector,MaxPooling1D,concatenate,Lambda,Multiply,Embedding,Permute,BatchNormalization\n",
    "from tensorflow.keras.callbacks import EarlyStopping\n",
    "from tensorflow.keras import optimizers,metrics\n",
    "from tensorflow.keras import Input, Model\n",
    "from tensorflow.keras import backend as k\n",
    "from tensorflow import keras\n",
    "from sklearn.model_selection import train_test_split\n",
    "from sklearn.metrics import mean_squared_error\n",
    "from sklearn.preprocessing import MinMaxScaler\n",
    "from sklearn.preprocessing import OneHotEncoder"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 数据转换"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 331,
   "metadata": {},
   "outputs": [],
   "source": [
    "def read_data():\n",
    "    file_dir = './data/train_data_1.csv'\n",
    "    all_data_frame = pd.read_csv(file_dir)\n",
    "    all_data_frame = all_data_frame[all_data_frame['ycsb']=='202106300288GF']\n",
    "    print('数据总量',all_data_frame.shape)\n",
    "    dfTest = all_data_frame[all_data_frame['time'].isin([20211114,20211113])]\n",
    "    all_data_frame = all_data_frame[~all_data_frame['time'].isin([20211114,20211113])]\n",
    "    return dfTest,all_data_frame\n",
    "\n",
    "def one_hot(data):\n",
    "    result = pd.get_dummies(data['weather'], sparse=True)\n",
    "    return result\n",
    "\n",
    "def scale(all_data_df):\n",
    "    #selected_features = ['hour', 'gfrl','cur_a','cur_b','cur_c','vol_a','vol_b','vol_c','p','szgl','low_tp', 'high_tp', 'avg_tp', 'wind']\n",
    "    #selected_features = ['hour', 'gfrl','cur_a','cur_b','cur_c','vol_a','vol_b','vol_c','p','szgl',\n",
    "     #                    '地面气压(hPa)', '气温2m(℃)', '地表温度(℃)', '相对湿度(%)', '风速','总云量(tcc)', '净日照强度(net,J/m2)']\n",
    "    selected_features = ['cur_a','cur_b','cur_c','p','szgl','净日照强度(net,J/m2)']\n",
    "    scaled_data = all_data_df[selected_features]\n",
    "    scaler = MinMaxScaler()\n",
    "    scaled_data = pd.DataFrame(scaler.fit_transform(scaled_data),columns=scaled_data.keys())\n",
    "    return scaled_data\n",
    "\n",
    "def label_encoder(features):\n",
    "    label_encoder = LabelEncoder()\n",
    "    for i, col in enumerate(features):\n",
    "        if features[col].dtype == 'object':\n",
    "            features[col] = label_encoder.fit_transform(np.array(features[col].astype(str)).reshape((-1,)))\n",
    "#           test_features[col] = label_encoder.transform(np.array(test_features[col].astype(str)).reshape((-1,)))\n",
    "    select_label = ['sbbm','ycsb','yhmc','weather']\n",
    "    return features[select_label]\n",
    "\n",
    "def inverse_scale(scaler,res):\n",
    "    pre_res  =scaler.inverse_transform(res)\n",
    "    return pre_res\n",
    "\n",
    "def slice_window(x_train,y_train,step):\n",
    "    X,y=[],[] \n",
    "    for i in range(0,len(x_train)-step,1): \n",
    "        end = i + step\n",
    "        oneX = x_train[i:end,:]\n",
    "        oney = y_train[end]\n",
    "        X.append(oneX)\n",
    "        y.append(oney)\n",
    "    return np.array(X),np.array(y)\n",
    "\n",
    "def data_transform(onehot_data,scale_data,all_data_df):\n",
    "    #充值索引，合并数据\n",
    "    onehot_data = onehot_data.reset_index()\n",
    "    scale_data = scale_data.reset_index()\n",
    "    #merge_data = pd.concat([onehot_data,scale_data], axis=1)\n",
    "    X_train = scale_data.drop('index',axis=1)\n",
    "    y = all_data_df['fdgl']\n",
    "    \n",
    "    #slice_window\n",
    "    step = 6\n",
    "    x_y = slice_window(np.array(X_train),np.array(y),step)\n",
    "    print('slice_window:',x_y[0].shape,x_y[1].shape)\n",
    "    X_train, y = x_y[0], x_y[1]\n",
    "    \n",
    "    #reshape参数\n",
    "#     sample = int(X_train.shape[0])//1\n",
    "#     time_step = 1\n",
    "#     feature_num = X_train.shape[1]\n",
    "#     #reshape\n",
    "#     X_train=X_train.values.reshape(sample,time_step,feature_num)\n",
    "#     y = y.values.reshape(sample,time_step)\n",
    "#     print('X:',X_train.shape)\n",
    "#     print('Y:',y.shape)\n",
    "    \n",
    "    #分割验证集\n",
    "    X_train,X_val,y_train,y_val=train_test_split(X_train,y,test_size=0.2, random_state=0)\n",
    "   \n",
    "    return [X_train,X_val,y_train,y_val]\n",
    "def data_transform2(onehot_data,scale_data,all_data_df):\n",
    "    #充值索引，合并数据\n",
    "    onehot_data = onehot_data.reset_index()\n",
    "    scale_data = scale_data.reset_index()\n",
    "    #merge_data = pd.concat([onehot_data,scale_data], axis=1)\n",
    "    X_train = scale_data.drop('index',axis=1)\n",
    "    y = all_data_df['fdgl']\n",
    "    \n",
    "    #slice_window\n",
    "    step = 6\n",
    "    x_y = slice_window(np.array(X_train),np.array(y),step)\n",
    "    print('slice_window:',x_y[0].shape,x_y[1].shape)\n",
    "    X_train, y = x_y[0], x_y[1]\n",
    "    \n",
    "    #reshape参数\n",
    "#     sample = int(X_train.shape[0])//1\n",
    "#     time_step = 1\n",
    "#     feature_num = X_train.shape[1]\n",
    "#     #reshape\n",
    "#     X_train=X_train.values.reshape(sample,time_step,feature_num)\n",
    "#     y = y.values.reshape(sample,time_step)\n",
    "#     print('X:',X_train.shape)\n",
    "#     print('Y:',y.shape)\n",
    "    \n",
    "    #分割验证集\n",
    "    #X_train,X_val,y_train,y_val=train_test_split(X_train,y,test_size=0, random_state=0)\n",
    "   \n",
    "    return [X_train,y]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 模型结构"
   ]
  },
  {
   "attachments": {
    "image.png": {
     "image/png": "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"
    }
   },
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "![image.png](attachment:image.png)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 332,
   "metadata": {},
   "outputs": [],
   "source": [
    "def train_model(train_val_data,model_type):\n",
    "    #获取数据\n",
    "    X_train,X_val,y_train,y_val = train_val_data[0],train_val_data[1],train_val_data[2],train_val_data[3]\n",
    "    print('训练数据总量',X_train.shape)\n",
    "    print('测试数据总量',X_val.shape)\n",
    "    #超参数\n",
    "    time_step = X_train.shape[1]\n",
    "    feature_nums = X_train.shape[2]\n",
    "    epochs=200\n",
    "    batch_size=16\n",
    "    patience=10\n",
    "    print('time_step:',time_step,'feature_nums:',feature_nums)\n",
    "    \n",
    "###########################################################################\n",
    "    if model_type =='lstm':\n",
    "        # LSTM \n",
    "        model = lstm_model([time_step,feature_nums])\n",
    "    if model_type =='conv1d_lstm':\n",
    "        # Conv1d-LSTM\n",
    "        model = conv1d_lstm_model([time_step,feature_nums])\n",
    "    if model_type =='conv2d_lstm':\n",
    "        # Conv2d-LSTM\n",
    "        model = conv2d_lstm_model([time_step,feature_nums,1])\n",
    "        X_train  = X_train.reshape(212, 6, 18, 1)\n",
    "        X_val  = X_val.reshape(54, 6, 18, 1)\n",
    "        \n",
    "    if model_type =='conv2d_lstm_att':\n",
    "        # Conv2d-LSTM\n",
    "        model = conv2d_lstm_attention([time_step,feature_nums,1])\n",
    "        X_train  = X_train.reshape(212, 6, 6, 1)\n",
    "        X_val  = X_val.reshape(54, 6, 6, 1)\n",
    "    \n",
    "    if model_type =='dou_cnn_lstm':\n",
    "        # double-Conv1d-LSTM\n",
    "        model = dou_cnn_lstm_model([time_step,feature_nums])\n",
    "    \n",
    "    if model_type =='cnn_lstm_att':\n",
    "        # cnn_lstm_attention\n",
    "        model = cnn_lstm_attention([time_step,feature_nums])\n",
    "###########################################################################\n",
    "\n",
    "    print(model.summary())\n",
    "    \n",
    "    # 转为tensor\n",
    "    X_train = k.cast_to_floatx(X_train)\n",
    "    y_train = k.cast_to_floatx(y_train)\n",
    "    X_val = k.cast_to_floatx(X_val)\n",
    "    y_val = k.cast_to_floatx(y_val)\n",
    "    \n",
    "    # 优化器\n",
    "    adam = optimizers.Adam(learning_rate = 0.0001)\n",
    "    #adam = optimizers.SGD(learning_rate = 0.001,momentum=0.2)\n",
    "    \n",
    "    # 损失函数\n",
    "    model.compile(loss='mse', optimizer=adam)\n",
    "    \n",
    "    #early_stop\n",
    "    early_stopping = EarlyStopping(monitor='val_loss', patience=patience, verbose=1)\n",
    "    \n",
    "    # 超参数\n",
    "    history = model.fit([X_train,X_train],y_train, \n",
    "                        epochs=epochs,\n",
    "                        batch_size=batch_size,\n",
    "                        validation_split=0.2,\n",
    "                        verbose=1,\n",
    "                        callbacks=[early_stopping], \n",
    "                        shuffle=False)\n",
    "    \n",
    "    y_val_pred = model.predict([X_val,X_val])\n",
    "    model.save('./model/lstm_空间相关性')\n",
    "    print('save_ok')\n",
    "    draw(history)\n",
    "    return [y_val,y_val_pred]\n",
    "\n",
    "def draw(history):\n",
    "    from matplotlib import pyplot\n",
    "    pyplot.plot(history.history['loss'], label='train')\n",
    "    pyplot.plot(history.history['val_loss'], label='test')\n",
    "    pyplot.legend()\n",
    "    pyplot.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 333,
   "metadata": {},
   "outputs": [],
   "source": [
    "# lstm\n",
    "def lstm_model(input_shape):\n",
    "    model = Sequential()\n",
    "    model.add(LSTM(64,activation='tanh', input_shape=(input_shape[0], input_shape[1])))\n",
    "    model.add(Dense(64,activation='relu'))\n",
    "    model.add(Dense(1,activation='relu'))\n",
    "    return model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 334,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "数据总量 (272, 33)\n",
      "slice_window: (234, 6, 6) (234,)\n",
      "训练数据总量 (187, 6, 6)\n",
      "测试数据总量 (47, 6, 6)\n",
      "time_step: 6 feature_nums: 6\n",
      "Model: \"sequential_1\"\n",
      "_________________________________________________________________\n",
      "Layer (type)                 Output Shape              Param #   \n",
      "=================================================================\n",
      "lstm_1 (LSTM)                (None, 64)                18176     \n",
      "_________________________________________________________________\n",
      "dense_2 (Dense)              (None, 64)                4160      \n",
      "_________________________________________________________________\n",
      "dense_3 (Dense)              (None, 1)                 65        \n",
      "=================================================================\n",
      "Total params: 22,401\n",
      "Trainable params: 22,401\n",
      "Non-trainable params: 0\n",
      "_________________________________________________________________\n",
      "None\n",
      "Train on 149 samples, validate on 38 samples\n",
      "Epoch 1/200\n",
      "149/149 [==============================] - 2s 12ms/sample - loss: 1.4647 - val_loss: 1.1736\n",
      "Epoch 2/200\n",
      "149/149 [==============================] - 0s 2ms/sample - loss: 1.4590 - val_loss: 1.1659\n",
      "Epoch 3/200\n",
      "149/149 [==============================] - 0s 987us/sample - loss: 1.4462 - val_loss: 1.1394\n",
      "Epoch 4/200\n",
      "149/149 [==============================] - 0s 1ms/sample - loss: 1.3998 - val_loss: 1.0595\n",
      "Epoch 5/200\n",
      "149/149 [==============================] - 0s 977us/sample - loss: 1.3054 - val_loss: 0.9702\n",
      "Epoch 6/200\n",
      "149/149 [==============================] - 0s 937us/sample - loss: 1.2149 - val_loss: 0.8979\n",
      "Epoch 7/200\n",
      "149/149 [==============================] - 0s 950us/sample - loss: 1.1403 - val_loss: 0.8373\n",
      "Epoch 8/200\n",
      "149/149 [==============================] - 0s 944us/sample - loss: 1.0766 - val_loss: 0.7857\n",
      "Epoch 9/200\n",
      "149/149 [==============================] - 0s 934us/sample - loss: 1.0200 - val_loss: 0.7373\n",
      "Epoch 10/200\n",
      "149/149 [==============================] - 0s 937us/sample - loss: 0.9650 - val_loss: 0.6920\n",
      "Epoch 11/200\n",
      "149/149 [==============================] - 0s 930us/sample - loss: 0.9120 - val_loss: 0.6511\n",
      "Epoch 12/200\n",
      "149/149 [==============================] - 0s 940us/sample - loss: 0.8625 - val_loss: 0.6153\n",
      "Epoch 13/200\n",
      "149/149 [==============================] - 0s 941us/sample - loss: 0.8176 - val_loss: 0.5862\n",
      "Epoch 14/200\n",
      "149/149 [==============================] - 0s 951us/sample - loss: 0.7787 - val_loss: 0.5640\n",
      "Epoch 15/200\n",
      "149/149 [==============================] - 0s 934us/sample - loss: 0.7458 - val_loss: 0.5482\n",
      "Epoch 16/200\n",
      "149/149 [==============================] - 0s 997us/sample - loss: 0.7189 - val_loss: 0.5377\n",
      "Epoch 17/200\n",
      "149/149 [==============================] - 0s 957us/sample - loss: 0.6972 - val_loss: 0.5306\n",
      "Epoch 18/200\n",
      "149/149 [==============================] - 0s 944us/sample - loss: 0.6793 - val_loss: 0.5252\n",
      "Epoch 19/200\n",
      "149/149 [==============================] - 0s 957us/sample - loss: 0.6637 - val_loss: 0.5199\n",
      "Epoch 20/200\n",
      "149/149 [==============================] - 0s 937us/sample - loss: 0.6493 - val_loss: 0.5134\n",
      "Epoch 21/200\n",
      "149/149 [==============================] - 0s 977us/sample - loss: 0.6359 - val_loss: 0.5060\n",
      "Epoch 22/200\n",
      "149/149 [==============================] - 0s 950us/sample - loss: 0.6230 - val_loss: 0.4976\n",
      "Epoch 23/200\n",
      "149/149 [==============================] - 0s 937us/sample - loss: 0.6103 - val_loss: 0.4882\n",
      "Epoch 24/200\n",
      "149/149 [==============================] - 0s 971us/sample - loss: 0.5972 - val_loss: 0.4781\n",
      "Epoch 25/200\n",
      "149/149 [==============================] - 0s 1ms/sample - loss: 0.5836 - val_loss: 0.4686\n",
      "Epoch 26/200\n",
      "149/149 [==============================] - 0s 1ms/sample - loss: 0.5697 - val_loss: 0.4584\n",
      "Epoch 27/200\n",
      "149/149 [==============================] - 0s 984us/sample - loss: 0.5555 - val_loss: 0.4480\n",
      "Epoch 28/200\n",
      "149/149 [==============================] - 0s 1ms/sample - loss: 0.5418 - val_loss: 0.4371\n",
      "Epoch 29/200\n",
      "149/149 [==============================] - 0s 1ms/sample - loss: 0.5282 - val_loss: 0.4257\n",
      "Epoch 30/200\n",
      "149/149 [==============================] - 0s 964us/sample - loss: 0.5146 - val_loss: 0.4141\n",
      "Epoch 31/200\n",
      "149/149 [==============================] - 0s 937us/sample - loss: 0.5009 - val_loss: 0.4025\n",
      "Epoch 32/200\n",
      "149/149 [==============================] - 0s 954us/sample - loss: 0.4873 - val_loss: 0.3909\n",
      "Epoch 33/200\n",
      "149/149 [==============================] - 0s 977us/sample - loss: 0.4736 - val_loss: 0.3789\n",
      "Epoch 34/200\n",
      "149/149 [==============================] - 0s 937us/sample - loss: 0.4589 - val_loss: 0.3651\n",
      "Epoch 35/200\n",
      "149/149 [==============================] - 0s 954us/sample - loss: 0.4442 - val_loss: 0.3513\n",
      "Epoch 36/200\n",
      "149/149 [==============================] - 0s 947us/sample - loss: 0.4296 - val_loss: 0.3375\n",
      "Epoch 37/200\n",
      "149/149 [==============================] - 0s 991us/sample - loss: 0.4140 - val_loss: 0.3222\n",
      "Epoch 38/200\n",
      "149/149 [==============================] - 0s 950us/sample - loss: 0.3980 - val_loss: 0.3067\n",
      "Epoch 39/200\n",
      "149/149 [==============================] - 0s 950us/sample - loss: 0.3822 - val_loss: 0.2913\n",
      "Epoch 40/200\n",
      "149/149 [==============================] - 0s 944us/sample - loss: 0.3660 - val_loss: 0.2776\n",
      "Epoch 41/200\n",
      "149/149 [==============================] - 0s 957us/sample - loss: 0.3506 - val_loss: 0.2646\n",
      "Epoch 42/200\n",
      "149/149 [==============================] - 0s 937us/sample - loss: 0.3366 - val_loss: 0.2532\n",
      "Epoch 43/200\n",
      "149/149 [==============================] - 0s 1ms/sample - loss: 0.3238 - val_loss: 0.2433\n",
      "Epoch 44/200\n",
      "149/149 [==============================] - 0s 1ms/sample - loss: 0.3114 - val_loss: 0.2335\n",
      "Epoch 45/200\n",
      "149/149 [==============================] - 0s 957us/sample - loss: 0.2992 - val_loss: 0.2240\n",
      "Epoch 46/200\n",
      "149/149 [==============================] - 0s 950us/sample - loss: 0.2883 - val_loss: 0.2163\n",
      "Epoch 47/200\n",
      "149/149 [==============================] - 0s 967us/sample - loss: 0.2790 - val_loss: 0.2099\n",
      "Epoch 48/200\n",
      "149/149 [==============================] - 0s 998us/sample - loss: 0.2712 - val_loss: 0.2052\n",
      "Epoch 49/200\n",
      "149/149 [==============================] - 0s 947us/sample - loss: 0.2649 - val_loss: 0.2016\n",
      "Epoch 50/200\n",
      "149/149 [==============================] - 0s 950us/sample - loss: 0.2596 - val_loss: 0.1986\n",
      "Epoch 51/200\n",
      "149/149 [==============================] - 0s 1ms/sample - loss: 0.2551 - val_loss: 0.1960\n",
      "Epoch 52/200\n",
      "149/149 [==============================] - 0s 1ms/sample - loss: 0.2513 - val_loss: 0.1939\n",
      "Epoch 53/200\n",
      "149/149 [==============================] - 0s 1ms/sample - loss: 0.2482 - val_loss: 0.1924\n",
      "Epoch 54/200\n",
      "149/149 [==============================] - 0s 1ms/sample - loss: 0.2455 - val_loss: 0.1910\n",
      "Epoch 55/200\n",
      "149/149 [==============================] - 0s 967us/sample - loss: 0.2432 - val_loss: 0.1898\n",
      "Epoch 56/200\n",
      "149/149 [==============================] - 0s 971us/sample - loss: 0.2412 - val_loss: 0.1884\n",
      "Epoch 57/200\n",
      "149/149 [==============================] - 0s 1ms/sample - loss: 0.2394 - val_loss: 0.1870\n",
      "Epoch 58/200\n",
      "149/149 [==============================] - 0s 1ms/sample - loss: 0.2379 - val_loss: 0.1860\n",
      "Epoch 59/200\n",
      "149/149 [==============================] - 0s 1ms/sample - loss: 0.2366 - val_loss: 0.1848\n",
      "Epoch 60/200\n",
      "149/149 [==============================] - 0s 1ms/sample - loss: 0.2354 - val_loss: 0.1836\n",
      "Epoch 61/200\n",
      "149/149 [==============================] - 0s 1ms/sample - loss: 0.2343 - val_loss: 0.1829\n",
      "Epoch 62/200\n",
      "149/149 [==============================] - 0s 1ms/sample - loss: 0.2333 - val_loss: 0.1823\n",
      "Epoch 63/200\n",
      "149/149 [==============================] - 0s 1ms/sample - loss: 0.2324 - val_loss: 0.1818\n",
      "Epoch 64/200\n",
      "149/149 [==============================] - 0s 1ms/sample - loss: 0.2316 - val_loss: 0.1812\n",
      "Epoch 65/200\n",
      "149/149 [==============================] - 0s 1ms/sample - loss: 0.2310 - val_loss: 0.1808\n",
      "Epoch 66/200\n",
      "149/149 [==============================] - 0s 1ms/sample - loss: 0.2304 - val_loss: 0.1806\n",
      "Epoch 67/200\n",
      "149/149 [==============================] - 0s 1ms/sample - loss: 0.2298 - val_loss: 0.1799\n",
      "Epoch 68/200\n",
      "149/149 [==============================] - 0s 1ms/sample - loss: 0.2293 - val_loss: 0.1793\n",
      "Epoch 69/200\n",
      "149/149 [==============================] - 0s 1ms/sample - loss: 0.2288 - val_loss: 0.1789\n",
      "Epoch 70/200\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "149/149 [==============================] - 0s 1ms/sample - loss: 0.2283 - val_loss: 0.1788\n",
      "Epoch 71/200\n",
      "149/149 [==============================] - 0s 1ms/sample - loss: 0.2280 - val_loss: 0.1785\n",
      "Epoch 72/200\n",
      "149/149 [==============================] - 0s 1ms/sample - loss: 0.2276 - val_loss: 0.1784\n",
      "Epoch 73/200\n",
      "149/149 [==============================] - 0s 1ms/sample - loss: 0.2274 - val_loss: 0.1781\n",
      "Epoch 74/200\n",
      "149/149 [==============================] - 0s 1ms/sample - loss: 0.2271 - val_loss: 0.1774\n",
      "Epoch 75/200\n",
      "149/149 [==============================] - 0s 1ms/sample - loss: 0.2267 - val_loss: 0.1771\n",
      "Epoch 76/200\n",
      "149/149 [==============================] - 0s 1ms/sample - loss: 0.2264 - val_loss: 0.1769\n",
      "Epoch 77/200\n",
      "149/149 [==============================] - 0s 1ms/sample - loss: 0.2262 - val_loss: 0.1767\n",
      "Epoch 78/200\n",
      "149/149 [==============================] - 0s 1ms/sample - loss: 0.2259 - val_loss: 0.1764\n",
      "Epoch 79/200\n",
      "149/149 [==============================] - 0s 1ms/sample - loss: 0.2256 - val_loss: 0.1763\n",
      "Epoch 80/200\n",
      "149/149 [==============================] - 0s 1ms/sample - loss: 0.2253 - val_loss: 0.1761\n",
      "Epoch 81/200\n",
      "149/149 [==============================] - 0s 1ms/sample - loss: 0.2251 - val_loss: 0.1756\n",
      "Epoch 82/200\n",
      "149/149 [==============================] - 0s 1ms/sample - loss: 0.2248 - val_loss: 0.1755\n",
      "Epoch 83/200\n",
      "149/149 [==============================] - 0s 1ms/sample - loss: 0.2245 - val_loss: 0.1753\n",
      "Epoch 84/200\n",
      "149/149 [==============================] - 0s 1ms/sample - loss: 0.2243 - val_loss: 0.1748\n",
      "Epoch 85/200\n",
      "149/149 [==============================] - 0s 1ms/sample - loss: 0.2240 - val_loss: 0.1746\n",
      "Epoch 86/200\n",
      "149/149 [==============================] - 0s 1ms/sample - loss: 0.2238 - val_loss: 0.1745\n",
      "Epoch 87/200\n",
      "149/149 [==============================] - 0s 1ms/sample - loss: 0.2236 - val_loss: 0.1741\n",
      "Epoch 88/200\n",
      "149/149 [==============================] - 0s 1ms/sample - loss: 0.2233 - val_loss: 0.1736\n",
      "Epoch 89/200\n",
      "149/149 [==============================] - 0s 1ms/sample - loss: 0.2231 - val_loss: 0.1736\n",
      "Epoch 90/200\n",
      "149/149 [==============================] - 0s 1ms/sample - loss: 0.2228 - val_loss: 0.1735\n",
      "Epoch 91/200\n",
      "149/149 [==============================] - 0s 1ms/sample - loss: 0.2227 - val_loss: 0.1730\n",
      "Epoch 92/200\n",
      "149/149 [==============================] - 0s 1ms/sample - loss: 0.2224 - val_loss: 0.1729\n",
      "Epoch 93/200\n",
      "149/149 [==============================] - 0s 1ms/sample - loss: 0.2222 - val_loss: 0.1728\n",
      "Epoch 94/200\n",
      "149/149 [==============================] - 0s 1ms/sample - loss: 0.2220 - val_loss: 0.1724\n",
      "Epoch 95/200\n",
      "149/149 [==============================] - 0s 1ms/sample - loss: 0.2217 - val_loss: 0.1721\n",
      "Epoch 96/200\n",
      "149/149 [==============================] - 0s 1ms/sample - loss: 0.2215 - val_loss: 0.1720\n",
      "Epoch 97/200\n",
      "149/149 [==============================] - 0s 1ms/sample - loss: 0.2212 - val_loss: 0.1720\n",
      "Epoch 98/200\n",
      "149/149 [==============================] - 0s 1ms/sample - loss: 0.2210 - val_loss: 0.1715\n",
      "Epoch 99/200\n",
      "149/149 [==============================] - 0s 1ms/sample - loss: 0.2207 - val_loss: 0.1713\n",
      "Epoch 100/200\n",
      "149/149 [==============================] - 0s 1ms/sample - loss: 0.2205 - val_loss: 0.1712\n",
      "Epoch 101/200\n",
      "149/149 [==============================] - 0s 1ms/sample - loss: 0.2203 - val_loss: 0.1706\n",
      "Epoch 102/200\n",
      "149/149 [==============================] - 0s 1ms/sample - loss: 0.2201 - val_loss: 0.1704\n",
      "Epoch 103/200\n",
      "149/149 [==============================] - 0s 1ms/sample - loss: 0.2199 - val_loss: 0.1704\n",
      "Epoch 104/200\n",
      "149/149 [==============================] - 0s 1ms/sample - loss: 0.2198 - val_loss: 0.1703\n",
      "Epoch 105/200\n",
      "149/149 [==============================] - 0s 1ms/sample - loss: 0.2196 - val_loss: 0.1698\n",
      "Epoch 106/200\n",
      "149/149 [==============================] - 0s 1ms/sample - loss: 0.2194 - val_loss: 0.1694\n",
      "Epoch 107/200\n",
      "149/149 [==============================] - 0s 1ms/sample - loss: 0.2192 - val_loss: 0.1697\n",
      "Epoch 108/200\n",
      "149/149 [==============================] - 0s 1ms/sample - loss: 0.2191 - val_loss: 0.1698\n",
      "Epoch 109/200\n",
      "149/149 [==============================] - 0s 1ms/sample - loss: 0.2190 - val_loss: 0.1692\n",
      "Epoch 110/200\n",
      "149/149 [==============================] - 0s 1ms/sample - loss: 0.2188 - val_loss: 0.1687\n",
      "Epoch 111/200\n",
      "149/149 [==============================] - 0s 1ms/sample - loss: 0.2185 - val_loss: 0.1686\n",
      "Epoch 112/200\n",
      "149/149 [==============================] - 0s 1ms/sample - loss: 0.2184 - val_loss: 0.1686\n",
      "Epoch 113/200\n",
      "149/149 [==============================] - 0s 1ms/sample - loss: 0.2183 - val_loss: 0.1686\n",
      "Epoch 114/200\n",
      "149/149 [==============================] - 0s 1ms/sample - loss: 0.2181 - val_loss: 0.1683\n",
      "Epoch 115/200\n",
      "149/149 [==============================] - 0s 1ms/sample - loss: 0.2179 - val_loss: 0.1681\n",
      "Epoch 116/200\n",
      "149/149 [==============================] - 0s 1ms/sample - loss: 0.2178 - val_loss: 0.1678\n",
      "Epoch 117/200\n",
      "149/149 [==============================] - 0s 1ms/sample - loss: 0.2176 - val_loss: 0.1675\n",
      "Epoch 118/200\n",
      "149/149 [==============================] - 0s 1ms/sample - loss: 0.2175 - val_loss: 0.1675\n",
      "Epoch 119/200\n",
      "149/149 [==============================] - 0s 1ms/sample - loss: 0.2173 - val_loss: 0.1674\n",
      "Epoch 120/200\n",
      "149/149 [==============================] - 0s 1ms/sample - loss: 0.2172 - val_loss: 0.1673\n",
      "Epoch 121/200\n",
      "149/149 [==============================] - 0s 1ms/sample - loss: 0.2170 - val_loss: 0.1672\n",
      "Epoch 122/200\n",
      "149/149 [==============================] - 0s 1ms/sample - loss: 0.2169 - val_loss: 0.1667\n",
      "Epoch 123/200\n",
      "149/149 [==============================] - 0s 1ms/sample - loss: 0.2167 - val_loss: 0.1666\n",
      "Epoch 124/200\n",
      "149/149 [==============================] - 0s 1ms/sample - loss: 0.2166 - val_loss: 0.1666\n",
      "Epoch 125/200\n",
      "149/149 [==============================] - 0s 1ms/sample - loss: 0.2165 - val_loss: 0.1663\n",
      "Epoch 126/200\n",
      "149/149 [==============================] - 0s 1ms/sample - loss: 0.2163 - val_loss: 0.1661\n",
      "Epoch 127/200\n",
      "149/149 [==============================] - 0s 1ms/sample - loss: 0.2162 - val_loss: 0.1659\n",
      "Epoch 128/200\n",
      "149/149 [==============================] - 0s 1ms/sample - loss: 0.2160 - val_loss: 0.1660\n",
      "Epoch 129/200\n",
      "149/149 [==============================] - 0s 1ms/sample - loss: 0.2159 - val_loss: 0.1659\n",
      "Epoch 130/200\n",
      "149/149 [==============================] - 0s 1ms/sample - loss: 0.2158 - val_loss: 0.1655\n",
      "Epoch 131/200\n",
      "149/149 [==============================] - 0s 1ms/sample - loss: 0.2157 - val_loss: 0.1651\n",
      "Epoch 132/200\n",
      "149/149 [==============================] - 0s 1ms/sample - loss: 0.2155 - val_loss: 0.1649\n",
      "Epoch 133/200\n",
      "149/149 [==============================] - 0s 1ms/sample - loss: 0.2153 - val_loss: 0.1651\n",
      "Epoch 134/200\n",
      "149/149 [==============================] - 0s 1ms/sample - loss: 0.2152 - val_loss: 0.1651\n",
      "Epoch 135/200\n",
      "149/149 [==============================] - 0s 1ms/sample - loss: 0.2152 - val_loss: 0.1648\n",
      "Epoch 136/200\n",
      "149/149 [==============================] - 0s 1ms/sample - loss: 0.2150 - val_loss: 0.1645\n",
      "Epoch 137/200\n",
      "149/149 [==============================] - 0s 2ms/sample - loss: 0.2148 - val_loss: 0.1643\n",
      "Epoch 138/200\n",
      "149/149 [==============================] - 0s 1ms/sample - loss: 0.2147 - val_loss: 0.1643\n",
      "Epoch 139/200\n",
      "149/149 [==============================] - 0s 1ms/sample - loss: 0.2146 - val_loss: 0.1641\n",
      "Epoch 140/200\n",
      "149/149 [==============================] - 0s 1ms/sample - loss: 0.2144 - val_loss: 0.1641\n",
      "Epoch 141/200\n",
      "149/149 [==============================] - 0s 1ms/sample - loss: 0.2143 - val_loss: 0.1638\n",
      "Epoch 142/200\n",
      "149/149 [==============================] - 0s 1ms/sample - loss: 0.2142 - val_loss: 0.1637\n",
      "Epoch 143/200\n",
      "149/149 [==============================] - 0s 1ms/sample - loss: 0.2141 - val_loss: 0.1637\n",
      "Epoch 144/200\n",
      "149/149 [==============================] - 0s 1ms/sample - loss: 0.2140 - val_loss: 0.1635\n",
      "Epoch 145/200\n",
      "149/149 [==============================] - 0s 1ms/sample - loss: 0.2138 - val_loss: 0.1631\n",
      "Epoch 146/200\n",
      "149/149 [==============================] - 0s 1ms/sample - loss: 0.2137 - val_loss: 0.1629\n",
      "Epoch 147/200\n",
      "149/149 [==============================] - 0s 1ms/sample - loss: 0.2135 - val_loss: 0.1629\n",
      "Epoch 148/200\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "149/149 [==============================] - 0s 1ms/sample - loss: 0.2135 - val_loss: 0.1628\n",
      "Epoch 149/200\n",
      "149/149 [==============================] - 0s 1ms/sample - loss: 0.2133 - val_loss: 0.1628\n",
      "Epoch 150/200\n",
      "149/149 [==============================] - 0s 1ms/sample - loss: 0.2132 - val_loss: 0.1625\n",
      "Epoch 151/200\n",
      "149/149 [==============================] - 0s 1ms/sample - loss: 0.2131 - val_loss: 0.1625\n",
      "Epoch 152/200\n",
      "149/149 [==============================] - 0s 1ms/sample - loss: 0.2130 - val_loss: 0.1627\n",
      "Epoch 153/200\n",
      "149/149 [==============================] - 0s 1ms/sample - loss: 0.2129 - val_loss: 0.1625\n",
      "Epoch 154/200\n",
      "149/149 [==============================] - 0s 1ms/sample - loss: 0.2128 - val_loss: 0.1619\n",
      "Epoch 155/200\n",
      "149/149 [==============================] - 0s 1ms/sample - loss: 0.2126 - val_loss: 0.1616\n",
      "Epoch 156/200\n",
      "149/149 [==============================] - 0s 1ms/sample - loss: 0.2124 - val_loss: 0.1617\n",
      "Epoch 157/200\n",
      "149/149 [==============================] - 0s 1ms/sample - loss: 0.2123 - val_loss: 0.1618\n",
      "Epoch 158/200\n",
      "149/149 [==============================] - 0s 1ms/sample - loss: 0.2122 - val_loss: 0.1616\n",
      "Epoch 159/200\n",
      "149/149 [==============================] - 0s 1ms/sample - loss: 0.2121 - val_loss: 0.1613\n",
      "Epoch 160/200\n",
      "149/149 [==============================] - 0s 1ms/sample - loss: 0.2119 - val_loss: 0.1613\n",
      "Epoch 161/200\n",
      "149/149 [==============================] - 0s 1ms/sample - loss: 0.2119 - val_loss: 0.1613\n",
      "Epoch 162/200\n",
      "149/149 [==============================] - 0s 1ms/sample - loss: 0.2118 - val_loss: 0.1610\n",
      "Epoch 163/200\n",
      "149/149 [==============================] - 0s 1ms/sample - loss: 0.2116 - val_loss: 0.1607\n",
      "Epoch 164/200\n",
      "149/149 [==============================] - 0s 1ms/sample - loss: 0.2114 - val_loss: 0.1608\n",
      "Epoch 165/200\n",
      "149/149 [==============================] - 0s 1ms/sample - loss: 0.2114 - val_loss: 0.1611\n",
      "Epoch 166/200\n",
      "149/149 [==============================] - 0s 1ms/sample - loss: 0.2113 - val_loss: 0.1610\n",
      "Epoch 167/200\n",
      "149/149 [==============================] - 0s 1ms/sample - loss: 0.2112 - val_loss: 0.1605\n",
      "Epoch 168/200\n",
      "149/149 [==============================] - 0s 1ms/sample - loss: 0.2110 - val_loss: 0.1601\n",
      "Epoch 169/200\n",
      "149/149 [==============================] - 0s 1ms/sample - loss: 0.2109 - val_loss: 0.1601\n",
      "Epoch 170/200\n",
      "149/149 [==============================] - 0s 1ms/sample - loss: 0.2108 - val_loss: 0.1603\n",
      "Epoch 171/200\n",
      "149/149 [==============================] - 0s 1ms/sample - loss: 0.2107 - val_loss: 0.1600\n",
      "Epoch 172/200\n",
      "149/149 [==============================] - 0s 1ms/sample - loss: 0.2105 - val_loss: 0.1597\n",
      "Epoch 173/200\n",
      "149/149 [==============================] - 0s 1ms/sample - loss: 0.2104 - val_loss: 0.1595\n",
      "Epoch 174/200\n",
      "149/149 [==============================] - 0s 1ms/sample - loss: 0.2102 - val_loss: 0.1595\n",
      "Epoch 175/200\n",
      "149/149 [==============================] - 0s 1ms/sample - loss: 0.2101 - val_loss: 0.1599\n",
      "Epoch 176/200\n",
      "149/149 [==============================] - 0s 1ms/sample - loss: 0.2101 - val_loss: 0.1599\n",
      "Epoch 177/200\n",
      "149/149 [==============================] - 0s 1ms/sample - loss: 0.2100 - val_loss: 0.1594\n",
      "Epoch 178/200\n",
      "149/149 [==============================] - 0s 1ms/sample - loss: 0.2098 - val_loss: 0.1590\n",
      "Epoch 179/200\n",
      "149/149 [==============================] - 0s 1ms/sample - loss: 0.2096 - val_loss: 0.1589\n",
      "Epoch 180/200\n",
      "149/149 [==============================] - 0s 1ms/sample - loss: 0.2095 - val_loss: 0.1589\n",
      "Epoch 181/200\n",
      "149/149 [==============================] - 0s 1ms/sample - loss: 0.2094 - val_loss: 0.1590\n",
      "Epoch 182/200\n",
      "149/149 [==============================] - 0s 1ms/sample - loss: 0.2093 - val_loss: 0.1590\n",
      "Epoch 183/200\n",
      "149/149 [==============================] - 0s 1ms/sample - loss: 0.2092 - val_loss: 0.1587\n",
      "Epoch 184/200\n",
      "149/149 [==============================] - 0s 1ms/sample - loss: 0.2090 - val_loss: 0.1586\n",
      "Epoch 185/200\n",
      "149/149 [==============================] - 0s 1ms/sample - loss: 0.2089 - val_loss: 0.1585\n",
      "Epoch 186/200\n",
      "149/149 [==============================] - 0s 1ms/sample - loss: 0.2088 - val_loss: 0.1585\n",
      "Epoch 187/200\n",
      "149/149 [==============================] - 0s 1ms/sample - loss: 0.2087 - val_loss: 0.1583\n",
      "Epoch 188/200\n",
      "149/149 [==============================] - 0s 1ms/sample - loss: 0.2086 - val_loss: 0.1581\n",
      "Epoch 189/200\n",
      "149/149 [==============================] - 0s 1ms/sample - loss: 0.2085 - val_loss: 0.1582\n",
      "Epoch 190/200\n",
      "149/149 [==============================] - 0s 1ms/sample - loss: 0.2083 - val_loss: 0.1581\n",
      "Epoch 191/200\n",
      "149/149 [==============================] - 0s 1ms/sample - loss: 0.2083 - val_loss: 0.1582\n",
      "Epoch 192/200\n",
      "149/149 [==============================] - 0s 1ms/sample - loss: 0.2081 - val_loss: 0.1581\n",
      "Epoch 193/200\n",
      "149/149 [==============================] - 0s 1ms/sample - loss: 0.2080 - val_loss: 0.1576\n",
      "Epoch 194/200\n",
      "149/149 [==============================] - 0s 1ms/sample - loss: 0.2079 - val_loss: 0.1574\n",
      "Epoch 195/200\n",
      "149/149 [==============================] - 0s 1ms/sample - loss: 0.2077 - val_loss: 0.1573\n",
      "Epoch 196/200\n",
      "149/149 [==============================] - 0s 1ms/sample - loss: 0.2076 - val_loss: 0.1575\n",
      "Epoch 197/200\n",
      "149/149 [==============================] - 0s 1ms/sample - loss: 0.2075 - val_loss: 0.1576\n",
      "Epoch 198/200\n",
      "149/149 [==============================] - 0s 1ms/sample - loss: 0.2075 - val_loss: 0.1572\n",
      "Epoch 199/200\n",
      "149/149 [==============================] - 0s 1ms/sample - loss: 0.2073 - val_loss: 0.1568\n",
      "Epoch 200/200\n",
      "149/149 [==============================] - 0s 1ms/sample - loss: 0.2071 - val_loss: 0.1568\n",
      "save_ok\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Wall time: 37 s\n"
     ]
    }
   ],
   "source": [
    "%%time\n",
    "if __name__=='__main__':\n",
    "    #读取原数据\n",
    "    dfTest,all_data_df = read_data()\n",
    "    #非数值数据onehot处理\n",
    "  \n",
    "    onehot_data = one_hot(all_data_df)\n",
    "    #数值数据归一化\n",
    "    scale_data = scale(all_data_df)\n",
    "    #拼接，shape转换，分割\n",
    "    train_val_data = data_transform(onehot_data,scale_data,all_data_df)\n",
    "    #训练模型\n",
    "    model_type = ['lstm','conv1d_lstm','conv2d_lstm','dou_cnn_lstm','cnn_lstm_att','conv2d_lstm_att']\n",
    "    train_model(train_val_data,model_type[0])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 基于空间相关性"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 335,
   "metadata": {},
   "outputs": [],
   "source": [
    "from tensorflow.keras.models import load_model\n",
    "model_path = './model/lstm_空间相关性'\n",
    "model = load_model(model_path)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 336,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "slice_window: (26, 6, 6) (26,)\n"
     ]
    }
   ],
   "source": [
    "onehot_data = one_hot(dfTest)\n",
    "#数值数据归一化\n",
    "scale_data = scale(dfTest)\n",
    "#拼接，shape转换，分割\n",
    "X_train,y = data_transform2(onehot_data,scale_data,all_data_df)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 380,
   "metadata": {},
   "outputs": [],
   "source": [
    "y_pred = model.predict(X_train)[10:26]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 381,
   "metadata": {},
   "outputs": [],
   "source": [
    "y_pred = y_pred.reshape(1,16)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 382,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[0.        , 0.04020803, 0.17068891, 0.23807211, 0.5005629 ,\n",
       "        1.3738345 , 1.9795387 , 2.3195662 , 2.387817  , 2.1664178 ,\n",
       "        1.7562664 , 1.0903679 , 0.27972335, 0.        , 0.        ,\n",
       "        0.        ]], dtype=float32)"
      ]
     },
     "execution_count": 382,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "y_pred"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 383,
   "metadata": {},
   "outputs": [],
   "source": [
    "a1 = np.array(label['fdgl'].tolist()[128:])\n",
    "a2 = np.array(label['fdgl'].tolist()[64:128]).reshape(4,16)\n",
    "xgxs = a2/a1\n",
    "xgxs[np.isnan(xgxs)] = 0\n",
    "xgxs[np.isinf(xgxs)] = 0\n",
    "# xgxs[np.isnan(xgxs)] = 0\n",
    "# xgxs[np.isinf(xgxs)] = 0\n",
    "# 相关性分析 系数\n",
    "xgxxs = [[0.        , 0.        , 0.        , 1.55688238, 1.29958118,\n",
    "        0.99755257, 0.98872796, 0.91762599, 1.05982101, 1.00890798,\n",
    "        1.04459411, 0.93244219, 0.28752875, 0.        , 0.        ,\n",
    "        0.        ],\n",
    "       [0.        , 0.        , 0.29137529, 0.1522724 , 0.14055502,\n",
    "        0.15938094, 0.20013178, 0.19135737, 0.1978807 , 0.21658132,\n",
    "        0.23689371, 0.27163852, 0.30531899, 0.32375032, 0.        ,\n",
    "        0.        ],\n",
    "       [0.        , 0.        , 0.        , 1.16861716, 1.16869919,\n",
    "        0.86710018, 0.92442738, 0.93572023, 0.97315481, 1.02674666,\n",
    "        1.20782345, 1.08806208, 0.39044083, 0.        , 0.        ,\n",
    "        0.        ],\n",
    "       [0.        , 0.        , 0.        , 3.01051578, 1.80717675,\n",
    "        1.11618008, 1.10035585, 1.06201845, 0.99394488, 0.99611732,\n",
    "        0.8141872 , 0.80557402, 0.66809513, 0.        , 0.        ,\n",
    "        0.        ]]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 384,
   "metadata": {},
   "outputs": [],
   "source": [
    "y_pred_ = y_pred*xgxxs*0.9"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 385,
   "metadata": {},
   "outputs": [],
   "source": [
    "y_pred_sum = np.concatenate((y_pred_,y_pred),axis = 0).sum(axis = 0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 378,
   "metadata": {},
   "outputs": [],
   "source": [
    "#np.savetxt('./y_pred.txt',y_pred_sum)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 386,
   "metadata": {},
   "outputs": [],
   "source": [
    "fact = [0.00000000e+00, 2.33100233e-03, 5.16550117e-03, 9.75381542e-01,\n",
    "       3.99701695e+00, 6.44879696e+00, 8.29413482e+00, 8.87955440e+00,\n",
    "       9.13233070e+00, 8.09311298e+00, 6.32011785e+00, 3.47240523e+00,\n",
    "       6.42695411e-01, 2.38275058e-03, 0.00000000e+00,5.82750583e-04]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 389,
   "metadata": {},
   "outputs": [],
   "source": [
    "np.savetxt('./y_pred_sum.txt',y_pred_sum)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 387,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 720x504 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "id = [i for i in range(16)]\n",
    "plt.figure(figsize=(10,7))\n",
    "plt.plot(id, fact, color='black',linewidth=2,label = '实际功率值')#线1\n",
    "plt.plot(id, y_pred_sum,color='green',linewidth=2,linestyle = '--',label = \"基于空间相关性\")#线2\n",
    "#plt.plot(id, p3,color='red',linewidth=2,linestyle = '--',label = 'DeepFm&LSTM')#线2\n",
    "plt.rcParams['font.sans-serif']=['SimHei']\n",
    "plt.legend(fontsize   = 15)\n",
    "plt.xlabel(\"时间采样点/小时\",fontsize   = 20)\n",
    "plt.ylabel(\"光伏发电功率/kW\",fontsize   = 20)\n",
    "plt.ylim(0,20)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 388,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "score: 0.6318004101049683\n",
      "rmse: 0.5827783331667326\n",
      "mape: 4.327413774803847\n",
      "mae: 0.38120474311412467\n",
      "mse: 0.33963058560859516\n"
     ]
    }
   ],
   "source": [
    "from sklearn import metrics\n",
    "y_val,y_val_pred =  fact,y_pred_sum\n",
    "MSE = metrics.mean_squared_error(y_val, y_val_pred)\n",
    "RMSE = metrics.mean_squared_error(y_val, y_val_pred)**0.5\n",
    "MAE = metrics.mean_absolute_error(y_val, y_val_pred)\n",
    "mape_ =[]\n",
    "for x,y in zip(y_val, y_val_pred):\n",
    "    if x!=0:\n",
    "        mape_.append(abs((x-y)/x))\n",
    "mape = np.array(mape_).sum()/len(mape_)\n",
    "score=1.0/(1.0+RMSE)\n",
    "print('score:',score)\n",
    "print('rmse:',RMSE)\n",
    "print('mape:',mape)\n",
    "print('mae:',MAE)\n",
    "print('mse:',MSE)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python [conda env:tf1.14]",
   "language": "python",
   "name": "conda-env-tf1.14-py"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.11"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}
